Source for file phpgettext.includes.php

Documentation is available at phpgettext.includes.php

  1. <?php
  2. defined( '_VALID_MOS' ) or die( 'Direct Access to this location is not allowed.' );
  3. /**
  4.  * function phpgettext()
  5.  *
  6.  * static function (we only need one phpgettext instance)
  7.  * loads a PHPGettext instance
  8.  * will detect if gettext is available and load compatibility file if it isn't
  9.  * 
  10.  */
  11.  
  12. class ActionHandler
  13. {
  14.     var $name;
  15.     var $action;
  16.     var $view;
  17.  
  18.     function ActionHandler($name)
  19.     {
  20.         $this->name  = $name;
  21.         $this->action  = requestvar('action', '_default');
  22.  
  23.         $views = $this->name.'Views';
  24.  
  25.         if (class_exists($views)) {
  26.             $this->view = new $views($this);
  27.         } else {
  28.             trigger_error("View class '$views' does not exist.", E_USER_ERROR);
  29.         }
  30.     }
  31.  
  32.     function run()
  33.     {
  34.         $method = $this->action;
  35.         /*
  36.         * do acl check here
  37.         */
  38.         if ($method && strlen($method) > 2 && method_exists($this, $method))
  39.         return $this->$method();
  40.  
  41.         return false;
  42.     }
  43.  
  44.     function redirect($url)
  45.     {
  46.         if (headers_sent()) {
  47.             echo "<script>document.location.href='$url';</script>\n";
  48.         } else {
  49.             while (@ob_end_clean()); // clear output buffer
  50.             header( "Location: $url" );
  51.         }
  52.         exit;
  53.     }
  54.     function &container($reset = false)
  55.     {
  56.         $name = '__com_' . $this->_name . '_container';
  57.         if (!isset($_SESSION[$name]) || $reset) {
  58.             $_SESSION[$name] = array();
  59.         }
  60.         return $_SESSION[$name];
  61.     }
  62.  
  63. }
  64.  
  65. class phpgettextActions extends ActionHandler
  66. {
  67.     function _default(){
  68.         $this->view->_default();
  69.     }
  70.     function view(){
  71.         require_once(dirname(__FILE__).'/phpgettext.catalog.php');
  72.  
  73.         $mode = requestvar('mode');
  74.         $lang = requestvar('lang');
  75.         $domain = requestvar('domain');
  76.         $textdomain = requestvar('textdomain');
  77.  
  78.         $catalog = new PHPGettext_catalog($domain, $textdomain);
  79.         $catalog->setproperty('mode', $mode);
  80.         $catalog->setproperty('lang', $lang);
  81.         $catalog->load();
  82.  
  83.         $renderer =& renderer();
  84.         $renderer->addbyref('catalog', $catalog);
  85.         $renderer->addvar('mode', $mode);
  86.         $renderer->addvar('comments', $catalog->comments);
  87.         $renderer->addvar('headers', $catalog->headers);
  88.         $renderer->addvar('strings', $catalog->strings);
  89.  
  90.         switch ($mode)
  91.         {
  92.             case 'mo':
  93.             return $this->view->view();
  94.             break;
  95.             case 'po':
  96.             return $this->view->form();
  97.             break;
  98.             case 'pot':
  99.             return $this->view->view();
  100.             break;
  101.             default:
  102.             trigger_error(__CLASS__.'->'.__FUNCTION__.' - mode not recognized', E_USER_ERROR);
  103.             return false;
  104.             break;
  105.         }
  106.     }
  107.     function extract(){
  108.         require_once(dirname(__FILE__).'/phpgettext.catalog.php');        
  109.         $gettext =& phpgettext();
  110.         $path = _site_path_;
  111.         $args = "--keyword=T_ --default-domain=phpgettext ";
  112.         $args .= '-o '.$path.'locale/phpgettext.pot ';
  113.         $args .= $path.'includes/*.php '.$path.'templates/*.php';
  114.         $gettext->xgettext($args);
  115.         $catalog = new PHPGettext_catalog('phpgettext', $path.'locale/');
  116.         $catalog->setproperty('mode', _MODE_POT_);
  117.         $catalog->load();
  118.  
  119.         $renderer =& renderer();
  120.         $renderer->addbyref('catalog', $catalog);        
  121.         $renderer->addvar('mode', 'pot');
  122.         $renderer->addvar('comments', $catalog->comments);
  123.         $renderer->addvar('headers', $catalog->headers);
  124.         $renderer->addvar('strings', $catalog->strings);
  125.         
  126.         return $this->view->view();
  127.     }
  128.     function cleartests(){
  129.         rmdirr('tests/locale/');
  130.         mkdir('tests/locale');
  131.         $this->redirect($_SERVER['PHP_SELF']);
  132.     }
  133.     
  134.     function delpot(){
  135.         $domain     = requestvar('domain');
  136.         $textdomain = requestvar('textdomain');
  137.         @unlink($textdomain.'/'.$domain.'.pot');
  138.         $this->redirect($_SERVER['PHP_SELF']);
  139.     }
  140.     function newfrompot(){
  141.         require_once(dirname(__FILE__).'/phpgettext.catalog.php');
  142.         $locale     = requestvar('locale');
  143.         $domain     = requestvar('domain');
  144.         $textdomain = requestvar('textdomain');
  145.         
  146.         $catalog =& new PHPGettext_catalog($domain, $textdomain);
  147.         $catalog->setproperty('mode', _MODE_POT_);
  148.         $catalog->load();
  149.         $catalog->setproperty('lang', $locale);
  150.         $catalog->setproperty('mode', _MODE_PO_);
  151.         $catalog->save();        
  152.         
  153.         $renderer =& renderer();
  154.         $renderer->addbyref('catalog', $catalog);        
  155.         $renderer->addvar('mode', _MODE_PO_);
  156.         $renderer->addvar('comments', $catalog->comments);
  157.         $renderer->addvar('headers', $catalog->headers);
  158.         $renderer->addvar('strings', $catalog->strings);
  159.         
  160.         return $this->view->form();
  161.     }
  162.     function runtests(){
  163.         ob_start();
  164.         require_once('tests/simpletest/unit_tester.php');
  165.         require_once('tests/simpletest/reporter.php');        
  166.         require_once(dirname(__FILE__).'/phpgettext.catalog.php');
  167.         /*
  168.         $test = &new GroupTest('PHPGettext tests');
  169.         $test->addTestFile('tests/gettext_test_cases.php');
  170.         $test->run(new HtmlReporter());
  171.         */
  172.         $test = &new GroupTest('PHPGettext_Catalog tests');
  173.         $test->addTestFile('tests/catalog_test_cases.php');
  174.         $test->run(new HtmlReporter());
  175.         $contents = ob_get_contents();
  176.         ob_end_clean();
  177.         $renderer =& renderer();
  178.         $renderer->addvar('content', $contents);
  179.         $this->view->display();
  180.     }
  181.     function save(){
  182.         require_once(dirname(__FILE__).'/phpgettext.catalog.php');
  183.         $domain     = trim(requestvar('domain'));
  184.         $textdomain = trim(requestvar('textdomain'));
  185.         $lang       = trim(requestvar('lang'));
  186.         $compile    = trim(requestvar('compile'));
  187.         $comments   = trim(requestvar('comments'));
  188.         $headers    = requestvar('headers');
  189.         $msgstr     = requestvar('msgstr');
  190.         $fuzzy      = requestvar('is_fuzzy');
  191.  
  192.         $catalog =& new PHPGettext_catalog($domain, $textdomain, $lang);
  193.         $catalog->setproperty('mode', 'po');
  194.         $catalog->setproperty('lang', $lang);
  195.         $catalog->load();
  196.  
  197.         if (isset($comments)) {
  198.             $comments = explode("\n", $comments);
  199.             if (is_array($comments)) {
  200.                 foreach ($comments as $comment)   {
  201.                     if (strpos($comment, '#') == 1)  {
  202.                         $catalog->comments .= $comment."\n";
  203.                     }
  204.                 }
  205.             }
  206.         }
  207.  
  208.         foreach ($headers as $key => $value) {
  209.             $catalog->headers[$key] = $value;
  210.         }
  211.  
  212.  
  213.         foreach ($msgstr as $index => $string) {
  214.             $catalog->strings[$index]->setmsgstr($string);
  215.             if (isset($is_fuzzy[$index])) {
  216.                 $catalog->strings[$index]->setfuzzy(true);
  217.             }
  218.         }
  219.         $catalog->save();
  220.         if ($compile > 0) {
  221.             $catalog->setproperty('mode', 'mo');
  222.             $catalog->save();
  223.         }
  224.         
  225.         $renderer =& renderer();
  226.         $renderer->addbyref('catalog', $catalog);        
  227.         $renderer->addvar('mode', _MODE_MO_);
  228.         $renderer->addvar('comments', $catalog->comments);
  229.         $renderer->addvar('headers', $catalog->headers);
  230.         $renderer->addvar('strings', $catalog->strings);
  231.         
  232.         return $this->view->view();
  233.     }
  234. }
  235.  
  236. class phpgettextViews
  237. {
  238.     var $action;
  239.  
  240.     function phpgettextViews(&$action) {
  241.         $this->action =& $action;
  242.     }
  243.     function _default()
  244.     {
  245.         $renderer =& renderer();
  246.         $renderer->addvar('content', $renderer->fetch('home.tpl.php'));
  247.         $this->display();
  248.     }
  249.  
  250.     function display() {
  251.         $renderer =& renderer();
  252.         $renderer->addbyref('view', $this);
  253.         $renderer->addbyref('t', phpgettext());
  254.         $renderer->display('main.tpl.php');
  255.     }
  256.  
  257.     function edit()
  258.     {
  259.         $renderer =& Renderer::instance('php');
  260.         $renderer->display();
  261.     }
  262.  
  263.  
  264.     function view()
  265.     {
  266.         $renderer =& renderer();
  267.         $renderer->addvar('content', $renderer->fetch('view.tpl.php'));
  268.         $this->display();
  269.     }
  270.  
  271.     function form()
  272.     {
  273.         $renderer =& renderer();
  274.         $renderer->addvar('content', $renderer->fetch('form.tpl.php'));
  275.         $this->display();
  276.     }
  277.  
  278.  
  279.     function dtree($return = false) {
  280.         $textdomains = $this->gettextdomains(rtrim($_SERVER['DOCUMENT_ROOT'], '/'));
  281.         $dtree =  "<script language=\"javascript\" type=\"text/javascript\">\n";
  282.         $dtree .= "d = new dTree('d', '"._site_url_."img/');\n";
  283.         $dtree .= "d.add(0,-1,'Text Domains');\n";
  284.         $cnt = 1;
  285.         foreach ($textdomains as $path) {
  286.             $name = str_replace($_SERVER['DOCUMENT_ROOT'], "", $path);
  287.             $name = str_replace(_gettext_dirname_, "", $name);
  288.             $name = rtrim(ucwords($name), '/');
  289.             if (strlen($name) < 1) {
  290.                 $name = T_("Main");
  291.             }
  292.             $dtree .= "d.add($cnt,0,'$name ($path)');\n"; // textdomains
  293.             $td = $cnt;
  294.             $cnt++;
  295.  
  296.             $translations = $this->getlanguages($path);
  297.  
  298.             if (is_array($translations)) {
  299.                 foreach ($translations as $lang => $files) {
  300.                     $dtree .= "d.add($cnt,$td,'$lang');\n"; // languages
  301.                     $lg = $cnt;
  302.                     $cnt++;
  303.  
  304.                     if (is_array($files)) {
  305.                         foreach ($files as $file) {
  306.                             if (is_array($file)) {
  307.                                 $dtree .= "d.add($cnt,$lg,'LC_MESSAGES');\n";
  308.                                 $mo = $cnt;
  309.                                 $cnt++;
  310.                                 foreach ($file as $k => $v) {
  311.                                     if (is_array($v)) {
  312.                                         foreach ($v as $f) {
  313.                                             $dom = substr($f, 0, -3);
  314.                                             $dtree .= "d.add($cnt, $mo, '$f', '".$_SERVER['PHP_SELF']."?action=view&mode=mo&lang=$lang&domain=$dom&textdomain=$path', '', '', '"._site_url_."img/square.gif');\n";
  315.                                             $cnt++;
  316.                                         }
  317.                                     }
  318.                                 }
  319.                             } else {
  320.                                 $dom = substr($file, 0, -3);
  321.                                 $dtree .= "d.add($cnt,$lg,'$file', '".$_SERVER['PHP_SELF']."?action=view&mode=po&lang=$lang&domain=$dom&textdomain=$path', '', '', '"._site_url_."img/add_content.gif');\n";
  322.                                 $cnt++;
  323.                             }
  324.                         }
  325.                     }
  326.                 }
  327.             }
  328.  
  329.  
  330.             $templates = $this->gettemplates($path);
  331.             for ($a=0; $a<count($templates); $a++) {
  332.                 $dom = substr($templates[$a], 0, -4);
  333.                 $dtree .= "d.add($cnt,$td,'".$templates[$a]."', '".$_SERVER['PHP_SELF']."?action=view&mode=pot&domain=$dom&textdomain=$path');\n";
  334.                 $cnt++;
  335.             }
  336.  
  337.         }
  338.         $dtree .= "document.write(d);\n";
  339.         $dtree .= "</script>\n";
  340.         if ($return)
  341.         return $dtree;
  342.  
  343.         echo $dtree;
  344.     }
  345.     function gettextdomains($path){
  346.         static $domains;
  347.         if ($handle=@opendir($path)) {
  348.             while (($file = readdir($handle)) !== false) {
  349.                 if (is_dir("$path/$file") && $file!= "." && $file!= "..") {
  350.                     if (preg_match('/^'._gettext_dirname_.'$/', $file)) {
  351.                         $domains[] = "$path/$file";
  352.                     }
  353.                     $this->gettextdomains("$path/$file");
  354.                 }
  355.             }
  356.             closedir($handle);
  357.         } else {
  358.             trigger_error(get_class($this)." File ( $path ) not found.", E_USER_ERROR);
  359.         }
  360.         return isset($domains) ? $domains : array();
  361.     }
  362.  
  363.     function getlanguages($domain) {
  364.         if ($handle = opendir($domain)) {
  365.             while (false !== ($file = readdir($handle))) {
  366.                 if (is_dir("$domain/$file") && $file!= "." && $file!= "..")
  367.                 $langs[$file] = $this->gettranslations("$domain/$file");
  368.             }
  369.             closedir($handle);
  370.         }
  371.         return (isset($langs) ? $langs : array());
  372.     }
  373.  
  374.     function gettemplates($textdomain) {
  375.         if ($handle=@opendir($textdomain)) {
  376.             while (($file = readdir($handle)) !== false)
  377.             if (preg_match('/.pot$/', $file))
  378.             $templates[] = $file;
  379.             closedir($handle);
  380.         } else {
  381.             trigger_error(get_class($this)." textdomain ( $path ) not found.", E_USER_ERROR);
  382.         }
  383.         return isset($templates) ? $templates : array();
  384.     }
  385.  
  386.     function gettranslations($path) {
  387.         $lang = basename($path);
  388.         if (is_dir($path) && $handle=@opendir($path)) {
  389.             while (($file = readdir($handle)) !== false) {
  390.                 if ($file== "LC_MESSAGES") {
  391.                     $po[]['LC_MESSAGES'] = $this->getbinaries($path.'/LC_MESSAGES');
  392.                 } elseif (preg_match('/.po$/', $file)) {
  393.                     $po[]= $file;
  394.                 }
  395.             }
  396.             closedir($handle);
  397.         } else {
  398.             trigger_error(get_class($this)." textdomain ( $path ) not found.", E_USER_ERROR);
  399.         }
  400.         return isset($po) ? $po : array();
  401.     }
  402.  
  403.     function getbinaries($path) {
  404.         if (is_dir($path) && $handle=@opendir($path)) {
  405.             while (($file = readdir($handle)) !== false) {
  406.                 if (preg_match('/.mo$/', $file)) {
  407.                     $mo[] = $file;
  408.                 }
  409.             }
  410.             closedir($handle);
  411.         } else {
  412.             trigger_error(get_class($this)." textdomain ( $path ) not found.", E_USER_ERROR);
  413.         }
  414.         return isset($mo) ? $mo : array();
  415.     }
  416.  
  417. }
  418.  
  419. class Renderer
  420. {
  421.  
  422.     var $dir;
  423.     var $vars = array();
  424.     var $engine = 'php';
  425.     var $template = '';
  426.  
  427.     function Renderer(){}
  428.  
  429.     function display($template, $return = false){
  430.         if ($template == NULL){
  431.             $error = 'A template has not been specified';
  432.             trigger_error($error, E_USER_ERROR);
  433.             return false;
  434.         }
  435.         $this->template = $this->dir . $template;
  436.  
  437.         if (is_readable($this->template)) {
  438.             extract($this->getvars());
  439.             if ($return) {
  440.                 ob_start();
  441.                 include_once($this->template);
  442.                 $ret = ob_get_contents();
  443.                 ob_end_clean();
  444.                 return $ret;
  445.             } else {
  446.                 include_once($this->template);
  447.             }
  448.         } else {
  449.             $error = 'Template file ' . $template . ' does ' . 'not exist or is not readable';
  450.             trigger_error($error, E_USER_ERROR);
  451.             return false;
  452.         }
  453.         return false;
  454.     }
  455.  
  456.     function fetch($template){
  457.         return $this->display($template, true);
  458.     }
  459.     function &getengine(){
  460.         return $this->engine;
  461.     }
  462.     function addvar($key, $value){
  463.         $this->vars[$key] = $value;
  464.     }
  465.     function addbyref ($key, &$value) {
  466.         $this->vars[$key] =& $value;
  467.     }
  468.     function getvars($name = false){
  469.         return (isset($this->vars[$name])) ? $this->vars[$name] : $this->vars;
  470.     }
  471.  
  472.     function setdir($dir){
  473.         $this->dir = (substr($dir, -1) == DIRECTORY_SEPARATOR) ? $dir : $dir.DIRECTORY_SEPARATOR;
  474.     }
  475.     function getdir(){
  476.         return $this->dir;
  477.     }
  478.     function template($template){
  479.         $this->template = $template;
  480.     }
  481. }
  482.  
  483.  
  484.  
  485.  
  486. // cleans out a directory recursively
  487. function rmdirr($dir) {
  488.     if($objs = glob($dir."/*")){
  489.         foreach($objs as $obj) {
  490.             is_dir($obj)? rmdirr($obj) : unlink($obj);
  491.         }
  492.     }
  493.     rmdir($dir);
  494. }
  495.  
  496.  
  497.  
  498.  
  499. function &renderer($engine = 'php') {
  500.     static $renderer;
  501.     if (is_null($renderer[$engine])) {
  502.         if ($engine == 'php') {
  503.             $renderer[$engine] = new Renderer();
  504.         } else {
  505.             $classname = $engine . 'Renderer';
  506.             if (class_exists($classname))
  507.             $renderer[$engine] = new $classname();
  508.         }
  509.     }
  510.     return $renderer[$engine];
  511. }
  512.  
  513.  
  514. function dump($var) {
  515.     $trace = debug_backtrace();
  516.     echo "<div>dump() in {$trace[0]['file']}:{$trace[0]['line']}</div>";
  517.     include_once 'Var_Dump.php';
  518.     if (class_exists('Var_Dump')) {
  519.         Var_Dump::displayInit(array('display_mode'=>'HTML4_Table'));
  520.         Var_Dump::display($var);
  521.     } else {
  522.         echo "<pre>";
  523.         var_dump($var);
  524.         echo "</pre>";
  525.     }
  526. }
  527.  
  528. function error_handler($errno, $errmsg, $filename, $linenum) {
  529.  
  530.     $dt = date("Y-m-d H:i:s (T)");
  531.     $errortype = array (
  532.     E_ERROR           => "Error",
  533.     E_WARNING         => "Warning",
  534.     E_PARSE           => "Parse Error",
  535.     E_NOTICE          => "Notice",
  536.     E_CORE_ERROR      => "Core Error",
  537.     E_CORE_WARNING    => "Core Warning",
  538.     E_COMPILE_ERROR   => "Compile Error",
  539.     E_COMPILE_WARNING => "Compile Warning",
  540.     E_USER_ERROR      => "User Error",
  541.     E_USER_WARNING    => "User Warning",
  542.     E_USER_NOTICE     => "User Notice"
  543.     );
  544.  
  545.     // set of errors for which a var trace will be saved
  546.     //$user_errors = array(E_USER_ERROR, E_USER_WARNING, E_USER_NOTICE);
  547.  
  548.     $output = <<<EOT
  549. <style type="text/css">
  550. <!-- 
  551.     .red_bold {color:red; font-weight:bold;}
  552.     .error { border: 1px solid grey; color: #000000;}
  553.     .error p.errmsg { font-size: 1em;  background-color: #990033; color: white; margin: 0 0 0 0;}
  554.     .error p.errfile { font-size: .8em; font-style: italic; margin: 0 0 0 20px;}
  555.     .error table.backtrace { }
  556.     .error table.backtrace th { text-align: left; background-color: #339900; color: white}
  557.     .error table.backtrace td {  color: #000000; background-color: #E8E8E8;}
  558.     .error table.backtrace span.function { font-weight: bold; }
  559.     .error table.backtrace span.file { font-size: .8em; font-style: italic; }
  560.     .error table.backtrace span.args { color: #000000; }
  561. -->
  562. </style>
  563. EOT;
  564.     $output .= "<div class=\"error\">";
  565.     $output .= "<p class=\"errmsg\">$errortype[$errno] : $errmsg</p>\n";
  566.     $output .= "<p class=\"errfile\">in file $filename : $linenum</p>\n";
  567.     $output .=  backtrace();
  568.     $output .= "</div>";
  569.     echo $output;
  570.     // save to the error log, and e-mail it if there is a critical user error
  571.     /*
  572.     error_log($err, 3, "/error.log");
  573.     if ($errno == E_USER_ERROR) {
  574.     mail("phpdev@example.com", "Critical User Error", $err);
  575.     }
  576.     */
  577. }
  578.  
  579. function backtrace(){
  580.     $backtrace = debug_backtrace();
  581.     $output = "<table class=\"backtrace\"  border=\"1\" cellpadding=\"0\" cellspacing=\"0\">";
  582.     $output .= "<tr><th>#</th><th>function / location</th><th>args</th></tr>";
  583.     $count = 0;
  584.     if (isset($backtrace[0]['line'])) {
  585.         foreach ($backtrace as $bt) {
  586.             $argstr = '';
  587.             $class = isset($bt['class']) ? $bt['class'] : '';
  588.             $type = isset($bt['type']) ? $bt['type'] : '';
  589.             $function = isset($bt['function']) ? $bt['function'] : '';
  590.             $file = isset($bt['file']) ? $bt['file'] : '';
  591.             $line = isset($bt['line']) ? $bt['line'] : '';
  592.             $args = isset($bt['args']) ? $bt['args'] : array();
  593.             foreach ($args as $a) {
  594.                 if (!empty($args)) {
  595.                     $argstr .= ', ';
  596.                 }
  597.                 switch (gettype($a)) {
  598.                     case 'integer':
  599.                     case 'double':
  600.                     $argstr .= $a;
  601.                     break;
  602.                     case 'string':
  603.                     $a = htmlspecialchars($a);
  604.                     $argstr .= "\"$a\"";
  605.                     break;
  606.                     case 'array':
  607.                     $argstr .= 'Array('.count($a).')';
  608.                     break;
  609.                     case 'object':
  610.                     $argstr .= 'Object('.get_class($a).')';
  611.                     break;
  612.                     case 'resource':
  613.                     $argstr .= 'Resource('.strstr($a, '#').')';
  614.                     break;
  615.                     case 'boolean':
  616.                     $argstr .= $a ? 'True' : 'False';
  617.                     break;
  618.                     case 'NULL':
  619.                     $argstr .= 'Null';
  620.                     break;
  621.                     default:
  622.                     $argstr .= 'Unknown';
  623.                 }
  624.             }
  625.             if ($count > 1) {
  626.                 $output .= "<tr>\n";
  627.                 $output .= "<td><span>".($count-1)."</span></td>\n";
  628.                 $output .= "<td><span class=\"function\">{$class}{$type}{$function}()</span><br />\n";
  629.                 $output .= "<span class=\"file\">{$file}:{$line}</span></td>\n";
  630.                 $output .= "<td><span class=\"args\">$argstr<br /></span></td>\n";
  631.                 $output .= "</tr>\n";
  632.             }
  633.             $count++;
  634.         }
  635.     }
  636.     $output .= "</table>\n";
  637.     return $output;
  638. }
  639.  
  640. ?>

Documentation generated on Mon, 05 May 2008 16:22:29 +0400 by phpDocumentor 1.4.0